#include   "Enseigne.h"

/** @brief creEnseigne
  *
  * @todo: document this function
  */
Enseigne* creEnseigne(int numEns,int codeUe,int ensCm,int ensTd,int ensTp)
    {
    Enseigne    *   enseigne=calloc(1,sizeof(Enseigne));
    initEnseigne(enseigne,numEns,codeUe,ensCm,ensTd,ensTp);
    return  enseigne;
    }

/** @brief initEnseigne
  *
  * @todo: document this function
  */
void initEnseigne(Enseigne*enseigne,int numEns,int codeUe,int ensCm,int ensTd,int ensTp)
    {
    enseigne->numEns=numEns;
    enseigne->codeUe=codeUe;
    enseigne->ensCm=ensCm;
    enseigne->ensTd=ensTd;
    enseigne->ensTp=ensTp;

    }

void libereEnseigne(Enseigne*enseigne)
{
	assert(enseigne!=NULL);
	enseigne->numEns=0;
    	enseigne->codeUe=0;
    	enseigne->ensCm=0;
    	enseigne->ensTd=0;
    	enseigne->ensTp=0;

}

void detEnseigne(Enseigne ** enseigne)
{
assert(*enseigne!=NULL);
libereEnseigne(*enseigne);
free(*enseigne);
enseigne=NULL;

}

TabUe* recUeEnseigne(Ens *ens)
{
    assert(ens!=NULL);
    assert(ens->numEns>0);
    return  recUeEnseigneParNumEns(ens->numEns);
}


/** @brief recUeEnseigne
  *
  * @todo: document this function
  */
TabUe* recUeEnseigneParNumEns(int numEns)
    {
    FILE* f;
    int i=1;
    UE **ues=calloc(i,sizeof(UE));

    f = fopen(ENSEIGNE_DB, "r");

    if (f==NULL)
        {
        printf("Erreur lors de l'ouverture de %s\n", ENSEIGNE_DB);
        exit(EXIT_FAILURE);
        }
    char*contenu=calloc(100,sizeof(char));
    while(fgets(contenu,100,f) != NULL)
        {
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if(numEns==atoi(tab[0]))
            {
            ues=realloc(ues,sizeof(Ens)*i);
            UE *ue=recUEParCode(atoi(tab[1]));

            ues[i-1]=ue;
            i++;

            }
            free(tabor);
            free(tab);
        }
    free(contenu);
    if(!feof(f))
        printf("autre probleme \n");

    fclose(f);
    TabUe*tabUe=calloc(1,sizeof(TabUe));
    tabUe->tabUe=ues;
    tabUe->nbUe=i-1;
    return tabUe;
    }




/** @brief recEnseigne
  *
  * @todo: document this function
  */
TabEnseigne* recEnseigne(Ens*ens)
{
    assert(ens!=NULL    &&  ens->numEns>0);
    return  recEnseigneParNumEns(ens->numEns);
}

/** @brief resEnseigneParNumEns
  *
  * @todo: document this function
  */
TabEnseigne* recEnseigneParNumEns(int numEns)
{
    FILE* f;
     int i=1;
    TabEnseigne   *tabEnseigne=calloc(1,sizeof(TabEnseigne));
    Enseigne**  enseignes=calloc(1,sizeof(Enseigne));

    f = fopen(ENSEIGNE_DB, "r");

    if (f==NULL)
        {
        printf("Erreur lors de l'ouverture de %s\n", ENSEIGNE_DB);
        exit(EXIT_FAILURE);
        }
    char*contenu=calloc(100,sizeof(char));
    while(fgets(contenu,100,f) != NULL)
        {
      char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if(numEns==atoi(tab[0]))
            {
            enseignes=realloc(enseignes,sizeof(Enseigne)*i);

            enseignes[i-1]=creEnseigne(atoi(tab[0]),atoi(tab[1]),atoi(tab[2]),atoi(tab[3]),atoi(tab[4]));
            i++;
            }
            free(tabor);
            free(tab);
        }
    free(contenu);
    if(!feof(f))
        printf("autre probleme \n");

    fclose(f);

    tabEnseigne->nbEnseigne=i-1;
    tabEnseigne->tabEnseigne=enseignes;

    if(i>0)
    {


    return  tabEnseigne;
    }
    return  NULL;




}











TabEnseignant* recEnseignantParUe(UE *ue)
{

    assert(ue!=NULL);
    assert(ue->codeUE>0);
    return  recEnseignantParCodeUE(ue->codeUE);

}

/** @brief recEnseigantParUE
  *
  * @todo: document this function
  */
TabEnseignant* recEnseignantParCodeUE(int codeUe)
    {
    FILE* f;
    int i=1;
    Ens **enseignants=calloc(i,sizeof(Ens));

    f = fopen(ENSEIGNE_DB, "r");

    if (f==NULL)
        {
        printf("Erreur lors de l'ouverture de %s\n", ENSEIGNE_DB);
        exit(EXIT_FAILURE);
        }
    char*contenu=calloc(100,sizeof(char));
    while(fgets(contenu,100,f) != NULL)
        {
       char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if(codeUe==atoi(tab[1]))
            {
            enseignants=realloc(enseignants,sizeof(Ens)*i);
            Ens *ens=recEnsParCode(atoi(tab[0]));

            enseignants[i-1]=ens;
            i++;

            }
            free(tabor);
            free(tab);
        }
        free(contenu);

    if(!feof(f))
        printf("autre probleme \n");

    fclose(f);
    TabEnseignant*tabEns=calloc(1,sizeof(TabEnseignant));
    tabEns->tabEns=enseignants;
    tabEns->nbEns=i-1;
    return tabEns;
    }

/** @brief saveEnseigneParElement
  *
  * @todo: document this function
  */
void saveEnseigneParElement(int numEns,int codeUe,int ensCm,int ensTd,int ensTp)
    {
    FILE* f;

    f = fopen(ENSEIGNE_DB, "a");

    if (f==NULL)
        {
        printf("Erreur lors de l'ouverture de %s\n", ENSEIGNE_DB);
        exit(EXIT_FAILURE);
        }
    fclose(f);
    if(recEnseigneParCodeUeNumEns(numEns,codeUe)==NULL)
        {
        f = fopen(ENSEIGNE_DB, "a");

        char*c_numEns=calloc(20,sizeof(char));
        char*c_codeUe=calloc(20,sizeof(char));
        char*c_ensCm=calloc(1,sizeof(char));
        char*c_ensTd=calloc(1,sizeof(char));
        char*c_ensTp=calloc(1,sizeof(char));
        sprintf(c_numEns,"%d",numEns);
        sprintf(c_codeUe,"%d",codeUe);
        sprintf(c_ensCm,"%d",ensCm);
        sprintf(c_ensTd,"%d",ensTd);
        sprintf(c_ensTp,"%d",ensTp);

        char*chaine=calloc(100,sizeof(char));

        strcat(chaine,c_numEns);
        strcat(chaine,":");
        strcat(chaine,c_codeUe);
        strcat(chaine,":");
        strcat(chaine,c_ensCm);
        strcat(chaine,":");
        strcat(chaine,c_ensTd);
        strcat(chaine,":");
        strcat(chaine,c_ensTp);
        strcat(chaine,"\n");

        fputs(chaine, f);
        free(c_codeUe);
        free(c_numEns);
        free(c_ensCm);
        free(c_ensTd);
        free(c_ensTp);
        free(chaine);

        fclose(f);
        }
    else
        {
        fclose(f);
        printf("Cette  enseignant est deja lier à cette UE, veuillez utiliser l'option de mise a jour!!!");
        }




    }

/** @brief saveEnseigne
  *
  * @todo: document this function
  */
void saveEnseigne(Enseigne*enseigne)
    {
    assert(enseigne!=NULL);
    saveEnseigneParElement(enseigne->numEns,enseigne->codeUe,enseigne->ensCm,enseigne->ensTd,enseigne->ensTp);

    }



/** @brief saveEnseignePourUe
  *
  * @todo: document this function
  */
void saveEnseignePourUe(Ens*enseignant,UE*ue,int  ensCM,int   ensTD,int   ensTP)
    {
    assert(enseignant!=NULL &&  ue!=NULL);
    Enseigne *  enseigne=creEnseigne(enseignant->numEns,ue->codeUE,ensCM,ensTD,ensTP);
    assert(enseigne!=NULL);
    saveEnseigne(enseigne);
    }

int supEnseigne(Enseigne*enseigne)
{
assert(enseigne!=NULL);
assert(enseigne->numEns>0);
assert(enseigne->codeUe);
return  supEnseigneParId(enseigne->numEns,enseigne->codeUe);
}

int supEnseigneParId( int  numEns,int  codeUe)
    {

    char *contenu=calloc(100,sizeof(char));
    FILE * fIn;
    FILE * fOut;

    if ((fIn = fopen(ENSEIGNE_DB, "r")) == NULL)
        return EXIT_FAILURE;

    if ((fOut = fopen("texte.tmp", "w")) == NULL)
        {
        fclose(fIn);
        return EXIT_FAILURE;
        }

    while (fgets(contenu,100, fIn))
        {
        char * ligne=calloc(100,sizeof(char));
        strcpy(ligne,contenu);
          char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if (atoi(tab[0]) != numEns  &&  ligne[1] !=codeUe)
            fputs(ligne, fOut);

        free(ligne);
        free(tabor);
        free(tab);
        }


    fclose(fIn);
    fclose(fOut);
    free(contenu);
    rename("texte.tmp", ENSEIGNE_DB);
    return 0;
    }

int modifEnseigne(Ens*enseignant,UE*ue,int ensCM,int ensTD,int ensTP)
{
    assert(enseignant!=NULL &&  ue!=NULL);
    assert(enseignant->numEns>0 &&  ue->codeUE>0);
    return  mdfEnseigneParElement(enseignant->numEns,ue->codeUE,ensCM,ensTD,ensTP);
}

/** @brief modifEnseigneUeEnsParElement
  *
  * @todo: document this function
  */
int mdfEnseigneParElement(int numEns,int codeUe,int ensCm,int ensTd,int ensTp)
    {
    if(supEnseigneParId( numEns,codeUe )==0)
        {
        saveEnseigneParElement(numEns,codeUe,ensCm,ensTd,ensTp);
        return  0;
        }
    else
        {
        return  -1;
        }
    }

/** @brief modifEnseigneUeEns
  *
  * @todo: document this function
  */
int mdfEnseigne(Enseigne *enseigne,int ensCm,int ensTd,int ensTp)
    {
    assert(enseigne!=NULL);
    return  mdfEnseigneParElement(enseigne->numEns,enseigne->codeUe,ensCm,ensTd,ensTp);

    }

/** @brief recEnseigneParCodeUeNumEns
  *
  * @todo: document this function
  */
Enseigne * recEnseigneParCodeUeNumEns(int numEns,int codeUe)
    {
    FILE* f;


    f = fopen(ENSEIGNE_DB, "r");

    if (f==NULL)
        {
        printf("Erreur lors de l'ouverture de %s\n", ENSEIGNE_DB);
        exit(EXIT_FAILURE);
        }
    char*contenu=calloc(100,sizeof(char));
    while(fgets(contenu,100,f) != NULL)
        {
      char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if(numEns==atoi(tab[0])  &&  codeUe==atoi(tab[1]))
            {
            return  creEnseigne(atoi(tab[0]),atoi(tab[1]),atoi(tab[2]),atoi(tab[3]),atoi(tab[4]));

            }
        }

    if(!feof(f))
        printf("autre probleme \n");

    fclose(f);


    return  NULL;
    }



